Learning Node.js Development

Learn the fundamentals of Node.js, and deploy and test Node.js

applications on the web

Andrew Mead

BIRMINGHAM - MUMBAI

Learning Node.js Development

any form or by any means, without the prior written permission of the publisher, except in the case of brief

quotations embedded in critical articles or reviews.

Every effort has been made in the preparation of this book to ensure the accuracy of the information

presented. However, the information contained in this book is sold without warranty, either express or

implied. Neither the author, nor Packt Publishing or its dealers and distributors, will be held liable for any

damages caused or alleged to have been caused directly or indirectly by this book.

Packt Publishing has endeavored to provide trademark information about all of the companies and products

mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the

accuracy of this information.

Acquisition Editor:

Ben Renow-Clarke

Content Development Editor:

Monika Sangwan

Technical Editors:

Anupam Tiwari, Gaurav Gavas

Copy Editors:

Safis Editing, Tom Jacob

Project Editor:

Suzanne Coutinho

Proofreader:

Safis Editing

Indexer:

Pratik Shirodkar

Production Coordinator:

Nilesh Mohite

First published: January 2018

Production reference: 1300118

Published by Packt Publishing Ltd.

Livery Place

35 Livery Street

Birmingham

B3 2PB, UK.

ISBN 978-1-78839-554-0

www.packtpub.com

mapt.io

Mapt is an online digital library that gives you full access to over 5,000 books

and videos, as well as industry leading tools to help you plan your personal

development and advance your career. For more information, please visit our

website.

Why subscribe?

Spend less time learning and more time coding with practical eBooks and

Videos from over 4,000 industry professionals

Improve your learning with Skill Plans built especially for you

Get a free eBook or video every month

Mapt is fully searchable

Copy and paste, print, and bookmark content

PacktPub.com

Did you know that Packt offers eBook versions of every book published, with

PDF and ePub files available? You can upgrade to the eBook version at

www.PacktP

ub.com

and as a print book customer, you are entitled to a discount on the eBook

copy. Get in touch with us at

service@packtpub.com

for more details.

www.PacktPub.com

, you can also read a collection of free technical articles, sign up

for a range of free newsletters, and receive exclusive discounts and offers on

Packt books and eBooks.

Contributor

About the author

Andrew Mead

is a full-stack developer living in beautiful Philadelphia! He

launched his first Udemy course in 2014 and had a blast teaching and helping

others. Since then, he has launched 3 courses with over 21,000 students and over

1,900 5-star reviews.

Andrew currently teaches Node, Gulp, and React. Before he started teaching, he

created a web app development company. He has helped companies of all sizes

launch production web applications to their customers. He has had the honor of

working with awesome companies such as Siemens, Mixergy, and Parkloco. He

has a Computer Science degree from Temple University, and he has been

programming for just over a decade. He loves creating, programming, launching,

learning, teaching, and biking.

Packt is searching for authors

like you

If you're interested in becoming an author for Packt, please visit

authors.packtpub.c om

and apply today. We have worked with thousands of developers and tech

professionals, just like you, to help them share their insight with the global tech

community. You can make a general application, apply for a specific hot topic

that we are recruiting an author for, or submit your own idea.

12 
 
 
Table of Contents 
Preface 
Who this book is for What 
this book covers 
To get the most out of this book Download 
the example code files 
Conventions used 
Get in touch 
Reviews 
1.
 
Getting Set Up 
Node.js installation 
Node.js version confirmation 
Installing Node 
Verifying installation What is 
Node? 
Differences between JavaScript coding using Node and in the browser Why use Node 
Blocking and non-blocking software development 
The working of blocking I/O The 
working non-blocking I/O 
Blocking and non-blocking examples using  Terminal Node community 
– problem solving open source  libraries 
Different text editors for node applications 
Hello World – creating and running the first Node app Creating the Node 
application 
Running the Node application 
Summary 
2.
 
Node Fundamentals – Part 1 
Module basics 
Using case for require() 
Initialization of an  application The 
built-in module to use  require() 
Creating and appending files in the File System module The OS module 
in require() 
Concatenating user.username 
Using template strings 
Require own files 
Making a new file to load other files Exporting files 
from note.js to use in app.js 

A simple example of the working of the exports object Exporting the

functions

Exercise – adding a new function to the export object

Solution to the exercise

Third-party modules

Creating projects using npm modules Installing the

lodash module in our app

Installation of lodash

Using the utilities of lodash Using the

_.isString utility Using _.uniq

The node_modules folder Global

modules

Installing the nodemon module

Executing nodemon

Getting input

Getting input from the user inside the command line

Accessing the command-line argument for the notes application Adding

if/else statements

Exercise – adding two else if clauses to an if block Solution to the

exercise

Getting the specific note information

Summary

Node Fundamentals – Part 2

yargs

JSON

Installing yargs Running

yargs

Working with the add command Working with

the list command

The read command

Dealing with the errors in parsing commands The remove

command

Fetching command

Converting objects into strings

Defining a string and using in app as an object Converting a string

back to an object

Storing the string in a file

Writing the file in the playground folder Reading out the

content in the file

Adding and saving notes Adding

notes

Adding notes to the notes array Fetching

new notes

Trying and catching code block

Making the title unique

Refactoring

Moving functionality into individual functions

Working with fetchNotes

Working with saveNotes

Testing the functionality

Summary

Node Fundamentals – Part 3

Removing a note

Using the removeNote function Printing a

message of removing notes

Reading note

Using the getNote function

Running the getNote function The

DRY principle

Using the logNote function

Debugging

Executing a program in debug mode Working

with debugging

Using debugger inside the notes application Listing

notes

Using the getAll function

Advanced yargs

Using chaining syntax on yargs

Calling the .help command Adding

the options object

Adding the title

Adding the body

Adding support to the read and remove commands Adding the

titleOption and bodyOption variables

Testing the remove command Arrow

functions

Using the arrow function

Exploring the difference between regular and arrow functions Exploring the

arguments array

Summary

Basics of Asynchronous Programming in Node.js The basic

concept of asynchronous program

Illustrating the async programming model Call

stack and event loop

A synchronous program example

The call stack

Running the synchronous program

A complex synchronous program example An async

program example

The Node API in async programming

The callback queue in async programming The

event loop

Running the async code

Callback functions and APIs

The callback function

Creating the callback function Running the

callback function

Simulating delay using setTimeout Making

request to Geolocation API

Using Google Maps API data in our code

Installing the request package Using

request as a function Running the

request

Pretty printing objects

Using the body argument Making

up of the HTTPS requests

The response object

The error argument

Printing data from the body object Printing

the formatted address Printing latitude

and longitude

Summary

Callbacks in Asynchronous Programming

Encoding user input

Installing yargs Configuring

yargs

Printing the address to screen Encoding and

decoding the strings

Encoding URI component

Decoding URI component

Pulling the address out of argv

Callback errors

Checking error in Google API request

Adding the if statement for callback errors

Adding if else statement to check body status property

Testing the body status property

Abstracting callbacks

Refactoring app.js and code into geocode.js file

Working on request statement

Creating geocode file

Adding callback function to geocodeAddress

Setting up the function in geocodeAddress function in app.js Implementing the

callback function in geocode.js file

Testing the callback function in geocode.js file Wiring up

weather search

Exploring working of API in the browser

Exploring the actual URL for code

Making a request for the weather app using the static URL Error handling

in the the callback function

Another way of error handling

Testing the error handling in callback Chaining

callbacks together

Refactoring our request call in weather.js file

Defining the new function getWeather in weather file Providing

weather directory in app.js

Passing the arguments in the getWeather function

Printing errorMessage in the getWeather function

Implementing getWeather callback inside weather.js file

Adding dynamic latitude and longitude

Changing console.log calls into callback calls Chaining the

geocodeAddress and getWeather callbacks together

Moving getWeather call into geocodeAddress function Replacing

static coordinates with dynamic coordinates Testing the chaining of

callbacks

Summary

Promises in Asynchronous Programming

Introduction to ES6 promises

Creating an example promise

Calling the promise method then Running the

promise example in Terminal Error handling in

promises

Merits of promises

Advanced promises

Providing input to promises

Returning the promises Promise

chaining

Error handling in promises chaining

The catch method The

request library in promises

Testing the request library Weather

app with promises

Fetching weather app code from the app.js file Axios

documentations

Installing axios

Making calls in the app-promise file

Making axios request

Error handling in axios request

Error handling with ZERO_RESULT body status

Generating the weather URL

Chaining the promise calls

Summary

Web Servers in Node

Introducing Express

Configuring Express

Express docs website

Installing Express

Creating an app

Exploring the developer tools in the browser for the app request

Passing HTML to res.send

Sending JSON data back

Error handling in the JSON request The

static server

Making an HTML page

The head tag The

body tag

Serving the HTML page in the Express app

The call to app.listen

Rendering templates

Installing the hbs module

Configuring handlebars Our

first template

Getting the static page for rendering Injecting

data inside of templates

Rendering the template for the root of the website Advanced

templates

Adding partials

Working of partial The

Header partial

The Handlebars helper

Arguments in Helper

Express Middleware

Exploring middleware

Creating a logger Printing

message to file

The maintenance middleware without the next object Testing the

maintenance middleware

Summary

Deploying Applications to Web

Adding version control

Installing Git

Git on macOS Git

on Windows

Testing the installation

Turning the node-web-server directory into a Git repository Using Git

Adding untracked files to commit

Making a commit Setting

up GitHub and SSH keys

Setting up SSH keys

SSH keys documentations

Working on commands

Generating a key

Starting up the SSH agent

Configuring GitHub

Testing the configuration

Creating a new repository

Setting up the repository

Deploying the node app to the Web

Installing Heroku command-line tools

SSH key to Heroku

Setting up in the application code for Heroku Changes

in the server.js file

Changes in the package.json file Making a

commit in Heroku

Running the Heroku create command

Summary

10.

Testing the Node Applications – Part 1 Basic

testing

Installing the testing module Testing

a Node project

Mocha – the testing framework

Creating a test file for the add function Creating the if

condition for the test

Testing the squaring a number function

Autorestarting the tests

Using assertion libraries in testing Node modules

Exploring assertion libraries

Chaining multiple assertions

Multiple assertions for the square function Exploring usage

of expect with bogus test

Using toBe and toNotBe to compare array/objects Using the

toEqual and toNotEqual assertions Using toInclude and

toExclude

Testing the setName method The

asynchronous testing

Creating the asyncAdd function using the setTimeout object Writing the

test for the asyncAdd function

Making assertion for the asyncAdd function

Adding the done argument

The asynchronous testing for the square function

Creating the async square function Writing

test for asyncSquare

Making assertions for the asyncSquare function

Summary

11.

Testing the Node Applications – Part 2 Testing

the Express application

Setting up testing for the Express app Testing the

Express app using SuperTest

The SuperTest documentation

Creating a test for the Express app Writing

the test for the Express app

Testing our first API request Setting

up custom status

Adding flexibility to SuperTest Creating

an express route

Writing the test for the express route

Organizing test with describe()

Adding describe() for individual methods

Adding the route describe block for the server.test.js file Test spies

Creating a test file for spies

Creating a spy

Setting up spies assertions

More details out of spy assertion Swapping

of the function with spy

Installing and setting up the rewire function Replacing db

with the spy

Writing a test to verify swapping of the function

Summary

Conclusion

Another Book You May Enjoy

Leave a review - let other readers know what you think

Preface

Welcome to Learning Node.js Development. This book is packed with a ton of

content, projects, challenges and real-world examples, all designed to teach you

Node by doing. This means you'll be getting your hands dirty early on in the

upcoming chapters writing some code, and you'll be writing code for every

project. You will be writing every line of code that powers our applications.

Now, we would require a text editor for this book. We have various text editor

options that you can use. I always recommend using

Atom

, which you can find

atom.io

. It's free, open-source, and it's available for all operating systems,

namely Linux, macOS, and Windows. It's created by the folks behind GitHub.

All the projects in the book are fun to build and they were designed to teach you

everything required to launch your own Node app, from planning to

development and testing to deploying. Now, as you launch these different Node

applications and move through the book, you will run into errors, which is bound

to happen. Maybe something doesn't get installed as expected, or maybe you try

to run an app and instead of getting the expected output, you get a really long

obscure error message. Don't worry, I am there to help. I'll show you tips and

tricks to get pass through those errors in the chapters. Let's go ahead and get to

it.

Who this book is for

This book targets anyone looking to launch their own Node applications, switch

careers, or freelance as a Node developer. You should have a basic understanding

of JavaScript in order to follow this book.

What this book covers

Chapter 1

, Getting Set Up, talks about what Node is and why you want to use it. In

this chapter, you'll learn Node installation and by the end of the chapter, you'll be

able to run your first Node application.

Chapter 2

, Node Fundamentals - Part 1, talks about building Node applications.

The Node Fundamentals topic has been divided into 3 parts. Part 1 of this topic

includes module basics, requiring own files, and third-party NPM modules.

Chapter 3

, Node Fundamentals - Part 2, continues our discussion on some more

Node fundamentals. This chapter explores yargs, JSON, the addNote function,

and refactor, moving functionality into individual functions and testing the

functionality.

Chapter 4

, Node Fundamentals - Part 3, includes things such as read and write

from the file system. We'll look into advanced yargs configuration, debugging

broken apps, and some new ES6 functions.

Chapter 5

, Basics of Asynchronous Programming in Node.js, covers basic

concepts, terms, and technologies related to the async programming, making it

super-practical and using it in our weather application.

Chapter 6

, Callbacks in Asynchronous Programming, is the second part of async

programming in Node. We'll look into callbacks, HTTPS requests, and error

handling inside of our callback functions. We'll also look into the forecast API

and fetching real-time weather data for our address.

Chapter 7

, Promises in Asynchronous Programming, is the third and last part of

async programming in Node. This chapter focuses on Promises, how it works,

why they are useful, and so on. At the end of this chapter, we'll use Promises in

our weather app.

Chapter 8

, Web Servers in Node, talks about Node web servers and integrating

version control into Node applications. We'll also introduce a framework called

Express, one of the most important NPM libraries.

Chapter 9

, Deploying Applications to Web, talks about deploying the applications

to the Web. We'll be using Git, GitHub, and deploy our live app to the Web using

these two services.

Chapter 10

, Testing the Node Applications- Part 1, talks about how we can test our

code to make sure it is working as expected. We'll work on setting up for testing

and then writing our test cases. We'll look into the basic testing framework and

asynchronous testing.

Chapter 11

, Testing the Node Application - Part 2, continues our journey of testing

Node applications. In this chapter, we'll work on testing the Express applications

and look into some advanced methods of testing.

To get the most out of this book

A web browser, we'll be using Chrome throughout the course book but any

browser will do, and Terminal, sometimes known as the command line on Linux

or the Command Prompt on Windows. Atom as the text editor. The following list

of modules will be used throughout the course of this book:

lodash

nodemon

yargs

request

axios

express

hbs

heroku

rewire

32 
 
 
Download the example code files 
You can download the example code files for this book from your account at 
www. 
packtpub.com
. If you purchased this book elsewhere, you can visit 
www.packtpub.com/su pport 
and register to have the files emailed directly to you.
 
 
You can download the code files by following these steps:
 
 
1.
 
Log in or register at 
www.packtpub.com
.
 
2.
 
Select the SUPPORT tab.
 
3.
 
Click on Code Downloads & Errata.
 
4.
 
Enter the name of the book in the Search box and follow the onscreen 
instructions.
 
 
Once the file is downloaded, please make sure that you unzip or extract the 
folder using the latest version of:
 
 
WinRAR/7-Zip for Windows 
Zipeg/iZip/UnRarX for Mac 
7-Zip/PeaZip for Linux
 
 
The code bundle for the book is also hosted on GitHub at 
https://github.com/PacktPu 
blishing/Learning-Node.js-Development
.  We  also  have  other  code  bundles  from  our  rich 
catalog of books and videos available at 
https://github.com/PacktPublishing/
. Check them 
out!
 

Conventions used

There are a number of text conventions used throughout this book.

CodeInText

: Indicates code words in text, database table names, folder names,

filenames, file extensions, pathnames, dummy URLs, user input, and Twitter

handles. Here is an example: "Mount the downloaded

WebStorm-10*.dmg

disk image

file as another disk in your system."

A block of code is set as follows:

console.log('Starting app.js');

const fs = require('fs'); const _ =

require('lodash'); const yargs =

require('yargs');

When we wish to draw your attention to a particular part of a code block, the

relevant lines or items are set in bold:

const argv = yargs.argv;

var command = process.argv[2];

console.log('Command:', command);

console.log('Process', process.argv);

console.log('Yargs', argv);

Any command-line input or output is written as follows:

cd hello-world node

app.js

Bold

: Indicates a new term, an important word, or words that you see onscreen.

For example, words in menus or dialog boxes appear in the text like this. Here is

an example: "Select System info from the Administration panel."

Warnings or important notes appear like this.

Tips and tricks appear like this.

34 
 
 
Get in touch 
Feedback from our readers is always welcome.
 
 
General feedback
: Email 
feedback@packtpub.com 
and mention the book title in the 
subject of your message. If you have questions about any aspect of this book, 
please email us at 
questions@packtpub.com
.
 
 
Errata
:  Although  we  have  taken  every  care  to  ensure  the  accuracy  of  our 
content, mistakes do happen. If you have found a mistake in this book, we would 
be grateful if you would report this to us. Please visit 
www.packtpub.com/submit-errata
, 
selecting your book, clicking on the Errata Submission Form link, and entering 
the details.
 
 
Piracy
: If you come across any illegal copies of our works in any form on the 
Internet, we would be grateful if you would provide us with the location address 
or  website  name.  Please  contact  us  at 
copyright@packtpub.com 
with  a  link  to  the 
material.
 
 
If you are interested in becoming an author
: If there is a topic that you have 
expertise in and you are interested in either writing or contributing to a book, 
please visit 
authors.packtpub.com
.
 

Reviews

Please leave a review. Once you have read and used this book, why not leave a

review on the site that you purchased it from? Potential readers can then see and

use your unbiased opinion to make purchase decisions, we at Packt can

understand what you think about our products, and our authors can see your

feedback on their book. Thank you!

For more information about Packt, please visit

packtpub.com

Getting Set Up

In this chapter, you'll get your local environment set up for the rest of the book.

Whether you're on macOS, Linux, or Windows, we'll install Node and look at

exactly how we can run Node applications.

We'll talk about what Node is, why you would ever want to use it, and why you

would want to use Node as opposed to something like Rails, C++, Java, or any

other language that can accomplish similar tasks. By the end of this chapter, you

will be running your very first Node application. It's going to be simple, but it is

going to get us to the path to creating real-world production Node apps, which is

the goal of this book.

More specifically, we'll cover the following topics:

Node.js installation

What Node is

Why use Node

Atom

Hello World

Node.js installation

Before we start talking about what Node is and why it's useful, you need to first

install Node on your machine, because in the next couple of sections, we'll want

to run a little bit of Node code.

Now, to get started, we just need two programs—a browser, I'll be using Chrome

throughout the book, but any browser will do, and Terminal. I'll use

Spotlight

open up Terminal, which is what it's known as on my operating system.

If you're on Windows, look for the Command Prompt, you can search using the

Windows key and then by typing

command prompt

, and on Linux, you're looking for

the command line, although depending on your distribution it might be called

Terminal or Command Prompt.

Now, once you have that program open, you'll see a screen, as shown in the

following screenshot:

Essentially, it's waiting for you to run a command. We'll run quite a few

commands from Terminal throughout the book. I'll discuss it in a few sections

later, so if you've never used this before, you can start navigating comfortably.

Node.js version confirmation

In the browser, we can head over to

nodejs.org

to grab the installer for the latest

version of Node(as shown here). In this book, we'll use the most recent version,

version 9.3.0:

It is important that you install a V8 version of Node.js. It doesn't

have to be 4.0, it could be 1.0, but it is important it's on that V8

branch, because there is a ton of new features that come along with

V8, including all of the features you might have come to love in the

browser using ES6.

ES6 is the next version of JavaScript and it comes with a lot of great

enhancements we'll be using throughout the book. If you look at the following

image, Node.js Long Term Support Release Schedule (

https://github.com/nodejs/LTS

you can see that the current Node version is V8, out in April 2017:

Before going further, I would like to talk about the Node release cycle. What I

have in the preceding image is the official release cycle, this is released by Node.

You'll notice that only next to the even Node numbers do you find the active

LTS, the blue bar, and the maintenance bar. Now, LTS stands for long-term

support, and this is the version that's recommended for most users. I'd

recommend that you stick with the currently offered LTS option (Node v 8.9.4

LTS), though anything on the left-hand side will do, this is shown as the two

green buttons on

nodejs.org

Now, as you can see, the major version numbers, bump every six months.

Regardless of any sort of big overarching change, this happens like clockwork

even if nothing drastic has changed. It's not like Angular where jumping from

1.0 to 2.0 was almost like using a completely different library. This is just not the

case with Node, what you're getting from this book is the latest and greatest

Node has to offer.

Installing Node

Once the version is confirmed and selected, all we have to do is to click the

required version button on the Node website (

nodejs.org

) and download the

installer. The installer is one of those basic click Next a few times and you're

done type of installers, there's no need to run any fancy commands. I'll start the

installer. As shown in the following screenshot, it'll just ask a few questions, then

let's click on Next or Continue through all of them:

You might want to specify a custom destination, but if you don't know what that

means, and you don't usually do it when installing programs, skip that step too.

Here, in the next screenshot, you can see that I'm using just 58.6 MB, no

problem.

I'll run the installer by entering my password. And once I enter my password, it

should really only take a couple of seconds to get Node installed:

As shown in the following screenshot, we have a message that says The

installation was completed successfully, which means we are good to go:

Verifying installation

Now that Node has been installed successfully, we can go ahead and verify that

by running Node from Terminal. Inside Terminal, I'll shut it down by going to

Quit Terminal and open it up again:

The reason I'm opening it up is because we've installed a new

command, and some Terminals require a restart before they will be

able to run that new command.

In our case, we restarted things and we can run our brand new command so,

we'll type it:

node -v

What we're doing in this command is we're running the Node command, and

we're passing in what's called a

flag

, a hyphen sign followed by a letter. It could

, it could be

, or in our case it's

. This command will print the version of

Node currently installed.

We might get an error like this:

If you try to run a command that doesn't exist, such as

nodeasdf

, you'll see

command not found. If you see this, it usually means the Node installer didn't

work correctly, or you haven't run it in the first place.

In our case though, running Node with the

flag should result in a number. In

our case, it's version 9.3.0. If you do have Node installed, and you see something

like the following screenshot, then you are done. In the next section, we'll start

exploring exactly what Node is.

What is Node?

Node came about when the original developers took JavaScript, something you

could usually only run inside the browser, and they let it run on your machine as

a standalone process. This means that we could create applications using

JavaScript outside the context of the browser.

Now, JavaScript previously had a limited feature set. When I used it in the

browser, I could do things such as update the URL and remove the Node logo,

adding click events or anything else, but I couldn't really do much more.

With Node, we now have a feature set that looks much more similar to other

languages, such as Java, Python, or PHP. Some of these are as follows:

We can write Node applications using the JavaScript syntax

You can manipulate your filesystem, creating and removing folders

You can create query databases directly

You can even create web servers using Node

These were things that were not possible in the past, and they are because of

Node.

Now, both Node and the JavaScript that gets executed inside of your browser,

they're both running on the exact same engine. It's called the V8 JavaScript

runtime engine. It's an open source engine that takes JavaScript code and

compiles it into much faster machine code. And that's a big part of what makes

Node.js so fast.

Machine code is low-level code that your computer can run directly without

needing to interpret it. Your machine only knows how to run certain types of

code, for example, your machine can't run JavaScript code or PHP code directly

without first converting it into low-level code.

Using this V8 engine, we can take our JavaScript code, compile it to much

quicker machine code, and execute that. This is where all those new features

come in. The V8 engine is written in a language called C++. So if you want to

extend the Node language, you don't write Node code, you write C++ code that

builds off of what V8 already has in place.

Now, we'll not be writing any C++ code in this book. This book is

not about adding onto Node, it is about using Node. So, we will

only be writing JavaScript code.

Speaking of JavaScript code, let's start writing some inside Terminal. Now,

throughout the book, we'll be creating files and executing those files, but we can

actually create a brand new Node process by running the

node

command.

Referring to the following screenshot, I have a little right caret, which is waiting

for JavaScript Node code, not a new command-prompt command:

This means that I can run something like

console.log

, which, as you probably

already know, logs a message to the screen.

log

is a function, so I'll call it as

such, opening and closing my parentheses, and passing in a string inside two

single quotes, a message

Hello world!,

as shown in the following command line:

console.log('Hello world!');

This will print Hello world to the screen. If I hit enter, Hello world! prints just

like you'd expect, as shown in the following code output:

Now, what actually happened behind the scenes? Well, this is what Node does. It

takes your JavaScript code, it compiles it into machine code, and executes it. In

the preceding code, you can see it executed our code, printing out Hello world!.

Now, the V8 engine is running behind the scenes when we execute this

command, and it's also running inside the Chrome browser.

If I open up the developer tools in Chrome by going to Settings | More Tools |

Developer Tools:

I can ignore most of the things. I'm just looking for the Console tab, as shown in

the following screenshot: